home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / editors / emacs / xemacs / xemacs-1.006 / xemacs-1 / lib / xemacs-19.13 / lisp / edebug / cl-specs.el < prev    next >
Encoding:
Text File  |  1995-01-31  |  12.0 KB  |  430 lines
  1. ;;; cl-specs.el - Edebug specs for cl.el
  2. ;; Keywords: lisp, tools, maint
  3.  
  4. ;; Edebug specs for cl.el, version 1.0
  5. ;; Copyright (C) 1993 Free Software Foundation, Inc.
  6.  
  7. ;; Written by Daniel LaLiberte <liberte@cs.uiuc.edu>.
  8. ;; To be used with edebug.el version 3.1 or later.
  9. ;; These are for the cl.el, version 2.02 or later,
  10. ;; by Dave Gillespie <daveg@synaptics.com>.
  11.  
  12. ;; This file need not be byte-compiled, but it shouldnt hurt.
  13. ;; The following causes cl-specs to be loaded when you use Edebug with cl.el.
  14. ;; (add-hook 
  15. ;;   'cl-load-hook
  16. ;;   (function 
  17. ;;    (lambda () 
  18. ;;      (add-hook 'edebug-setup-hook 
  19. ;;            (function (lambda () (load-library "cl-specs")))))))
  20.  
  21. (require 'edebug)
  22.  
  23. ;; Blocks
  24.  
  25. (def-edebug-spec block (symbolp body))
  26. (def-edebug-spec return (&optional form))
  27. (def-edebug-spec return-from (symbolp &optional form))
  28.  
  29. ;; Loops
  30.  
  31. (def-edebug-spec when t)
  32. (def-edebug-spec unless t)
  33. (def-edebug-spec case (form &rest (sexp body)))
  34. (def-edebug-spec ecase case)
  35. (def-edebug-spec do
  36.   ((&rest &or symbolp (symbolp &optional form form))
  37.    (form body) 
  38.    cl-declarations body))
  39. (def-edebug-spec do* do)
  40. (def-edebug-spec dolist 
  41.   ((symbolp form &optional form) cl-declarations body))
  42. (def-edebug-spec dotimes dolist)
  43. (def-edebug-spec dosymbols 
  44.   ((symbolp &optional form form) cl-declarations body))
  45. (def-edebug-spec do-all-symbols 
  46.   ((symbolp &optional form) cl-declarations body))
  47.  
  48. ;; Multiple values
  49.  
  50. (def-edebug-spec multiple-value-list (form))
  51. (def-edebug-spec multiple-value-call (function-form body))
  52. (def-edebug-spec multiple-value-bind 
  53.   ((&rest symbolp) form cl-declarations body))
  54. (def-edebug-spec multiple-value-setq ((&rest symbolp) form))
  55. (def-edebug-spec multiple-value-prog1 (form body))
  56.  
  57. ;; Bindings
  58.  
  59. (def-edebug-spec lexical-let let)
  60. (def-edebug-spec lexical-let* let)
  61.  
  62. (def-edebug-spec psetq setq)
  63. (def-edebug-spec progv (form form body))
  64.  
  65. (def-edebug-spec flet ((&rest (defun*)) cl-declarations body))
  66. (def-edebug-spec labels flet)
  67.  
  68. (def-edebug-spec macrolet 
  69.   ((&rest (&define name (&rest arg) cl-declarations-or-string def-body)) 
  70.    cl-declarations body))
  71.  
  72. (def-edebug-spec symbol-macrolet 
  73.   ((&rest (symbol sexp)) cl-declarations body))
  74.  
  75. (def-edebug-spec destructuring-bind
  76.   (&define cl-macro-list form cl-declarations def-body))
  77.  
  78. ;; Setf
  79.  
  80. (def-edebug-spec setf (&rest [place form])) ;; sexp is not specific enough
  81. (def-edebug-spec psetf setf)
  82.  
  83. (def-edebug-spec letf  ;; *not* available in Common Lisp
  84.   ((&rest (fence place &optional form))
  85.    body))
  86. (def-edebug-spec letf* letf)
  87.  
  88.  
  89. (def-edebug-spec defsetf 
  90.   (&define name 
  91.        [&or [symbolp &optional stringp]
  92.         [cl-lambda-list (symbolp)]]
  93.        cl-declarations-or-string def-body))
  94.  
  95. (def-edebug-spec define-setf-method 
  96.   (&define name cl-lambda-list cl-declarations-or-string def-body))
  97.  
  98. (def-edebug-spec define-modify-macro
  99.   (&define name cl-lambda-list ;; should exclude &key
  100.        symbolp &optional stringp))
  101.  
  102. (def-edebug-spec callf
  103.   ([&or symbolp lambda-expr] place &rest form))
  104.  
  105. (def-edebug-spec callf2
  106.   ([&or symbolp lambda-expr] form place &rest form))
  107.  
  108. ;; Other operations on places
  109.  
  110. (def-edebug-spec remf (place form))
  111.  
  112. (def-edebug-spec incf (place &optional form))
  113. (def-edebug-spec decf incf)
  114. (def-edebug-spec push (form place))
  115. (def-edebug-spec pushnew 
  116.   (form place &rest [[&or ":test" ":test-not" ":key"] function-form]))
  117. (def-edebug-spec pop (place))
  118.  
  119. (def-edebug-spec shiftf (&rest place))  ;; really [&rest place] form
  120. (def-edebug-spec rotatef (&rest place))
  121.  
  122.  
  123. ;; Functions with function args.  These are only useful if the
  124. ;; function arg is quoted with ' instead of function.
  125.  
  126. (def-edebug-spec some (function-form form &rest form))
  127. (def-edebug-spec every some)
  128. (def-edebug-spec notany some)
  129. (def-edebug-spec notevery some)
  130.  
  131. ;; Mapping
  132.  
  133. (def-edebug-spec map (form function-form form &rest form))
  134. (def-edebug-spec maplist (function-form form &rest form))
  135. (def-edebug-spec mapc maplist)
  136. (def-edebug-spec mapl maplist)
  137. (def-edebug-spec mapcan maplist)
  138. (def-edebug-spec mapcon maplist)
  139.  
  140. ;; Sequences
  141.  
  142. (def-edebug-spec reduce (function-form form &rest form))
  143.  
  144. ;; Types and assertions
  145.  
  146. (def-edebug-spec cl-type-spec (sexp)) ;; not worth the trouble to specify, yet.
  147.  
  148. (def-edebug-spec deftype defmacro*)
  149. (def-edebug-spec check-type (place cl-type-spec &optional stringp))
  150. ;; (def-edebug-spec assert (form &optional form stringp &rest form))
  151. (def-edebug-spec assert (form &rest form))
  152. (def-edebug-spec typecase (form &rest ([&or cl-type-spec "otherwise"] body)))
  153. (def-edebug-spec etypecase typecase)
  154.  
  155. (def-edebug-spec ignore-errors t)
  156.  
  157. ;; Time of Evaluation
  158.  
  159. (def-edebug-spec eval-when
  160.   ((&rest &or "compile" "load" "eval") body))
  161. (def-edebug-spec eval-when-compile t)
  162. (def-edebug-spec load-time-value (form &optional &or "t" "nil"))
  163.  
  164. ;; Declarations
  165.  
  166. (def-edebug-spec cl-decl-spec 
  167.   ((symbolp &rest sexp)))
  168.  
  169. (def-edebug-spec cl-declarations
  170.   (&rest ("declare" &rest cl-decl-spec)))
  171.  
  172. (def-edebug-spec cl-declarations-or-string
  173.   (&or stringp cl-declarations))
  174.  
  175. (def-edebug-spec declaim (&rest cl-decl-spec))
  176. (def-edebug-spec declare (&rest cl-decl-spec))  ;; probably not needed.
  177. (def-edebug-spec locally (cl-declarations &rest form))
  178. (def-edebug-spec the (cl-type-spec form))
  179.  
  180. ;;======================================================
  181. ;; Lambda things
  182.  
  183. (def-edebug-spec cl-lambda-list
  184.   (([&rest arg]
  185.     [&optional ["&optional" cl-&optional-arg &rest cl-&optional-arg]]
  186.     [&optional ["&rest" arg]]
  187.     [&optional ["&key" [cl-&key-arg &rest cl-&key-arg]
  188.         &optional "&allow-other-keywords"]]
  189.     [&optional ["&aux" &rest
  190.         &or (symbolp &optional def-form) symbolp]]
  191.     )))
  192.  
  193. (def-edebug-spec cl-&optional-arg
  194.   (&or (arg &optional def-form arg) arg))
  195.  
  196. (def-edebug-spec cl-&key-arg
  197.   (&or ([&or (symbolp arg) arg] &optional def-form arg) arg))
  198.  
  199. (def-edebug-spec cl-macro-list
  200.   (([&optional "&environment" arg]  ;; only allowed first and last.
  201.     [&rest cl-macro-arg]
  202.     [&optional ["&optional" &rest 
  203.         &or (cl-macro-arg &optional def-form cl-macro-arg) 
  204.         arg]]
  205.     [&optional [[&or "&rest" "&body"] cl-macro-arg]]
  206.     [&optional ["&key" [&rest 
  207.             [&or ([&or (symbolp cl-macro-arg) arg] 
  208.                   &optional def-form cl-macro-arg)
  209.                  arg]]
  210.         &optional "&allow-other-keywords"]]
  211.     [&optional ["&aux" &rest
  212.         &or (symbolp &optional def-form) symbolp]]
  213.     [&optional "&environment" arg]  ;; only allowed first and last.
  214.     )))
  215.  
  216. (def-edebug-spec cl-macro-arg
  217.   (&or arg cl-macro-list1))
  218.  
  219. (def-edebug-spec cl-macro-list1
  220.   (([&optional "&whole" arg]  ;; only allowed at lower levels
  221.     [&rest cl-macro-arg]
  222.     [&optional ["&optional" &rest 
  223.         &or (cl-macro-arg &optional def-form cl-macro-arg) 
  224.         arg]]
  225.     [&optional [[&or "&rest" "&body"] cl-macro-arg]]
  226.     [&optional ["&key" [&rest 
  227.             [&or ([&or (symbolp cl-macro-arg) arg] 
  228.                   &optional def-form cl-macro-arg)
  229.                  arg]]
  230.         &optional "&allow-other-keywords"]]
  231.     [&optional ["&aux" &rest
  232.         &or (symbolp &optional def-form) symbolp]]
  233.     . [&or arg nil])))
  234.  
  235.  
  236. (def-edebug-spec defun*
  237.   ;; Same as defun but use cl-lambda-list.
  238.   (&define name cl-lambda-list
  239.        cl-declarations-or-string
  240.        [&optional ("interactive" interactive)]
  241.        def-body))
  242. (def-edebug-spec defsubst* defun*)
  243.  
  244. (def-edebug-spec defmacro* 
  245.   (&define name cl-macro-list cl-declarations-or-string def-body))
  246. (def-edebug-spec define-compiler-macro defmacro*)
  247.  
  248.  
  249. (def-edebug-spec function*
  250.   (&or symbolp ("lambda" cl-lambda-expr)))
  251.  
  252. (def-edebug-spec cl-lambda-expr
  253.   (&define cl-lambda-list
  254.        ;cl-declarations-or-string
  255.        ;[&optional ("interactive" interactive)]
  256.        def-body))
  257.  
  258.  
  259. ;;======================================================
  260. ;; Structures
  261. ;; (def-edebug-spec defstruct (&rest sexp)) would be sufficient, but...
  262.  
  263. ;; defstruct may contain forms that are evaluated when a structure is created.
  264. (def-edebug-spec defstruct
  265.   (&define  ; makes top-level form not be wrapped
  266.    [&or symbolp
  267.     (fence
  268.      symbolp &rest 
  269.          (&or [":conc-name" &or stringp "nil"]
  270.               [":constructor" symbolp &optional cl-lambda-list]
  271.               [":copier" symbolp]
  272.               [":predicate" symbolp]
  273.               [":include" symbolp &rest sexp];; not finished
  274.               ;; The following are not supported.
  275.               ;; [":print-function" ...]
  276.               ;; [":type" ...]
  277.               ;; [":initial-offset" ...]
  278.               ))]
  279.    [&optional stringp]
  280.    &rest &or symbolp (symbolp def-form &optional ":read-only" sexp)))
  281.  
  282. ;;======================================================
  283. ;; Loop macro is in several parts.
  284.  
  285. (def-edebug-spec loop
  286.   ([&optional ["named" symbolp]]
  287.    [&rest 
  288.     &or
  289.     ["repeat" form]
  290.     loop-for-as
  291.     loop-with
  292.     loop-initial-final]
  293.    [&rest loop-clause]
  294.    ))
  295.  
  296. (def-edebug-spec loop-with
  297.   ("with" loop-var
  298.    loop-type-spec
  299.    [&optional ["=" form]]
  300.    &rest ["and" loop-var
  301.       loop-type-spec
  302.       [&optional ["=" form]]]))
  303.  
  304. (def-edebug-spec loop-for-as
  305.   ([&or "for" "as"] loop-for-as-subclause
  306.    &rest ["and" loop-for-as-subclause]))
  307.  
  308. (def-edebug-spec loop-for-as-subclause
  309.   (loop-var 
  310.    loop-type-spec
  311.    &or 
  312.    [[&or "in" "on" "in-ref" "across-ref"]
  313.     form &optional ["by" function-form]]
  314.  
  315.    ["=" form &optional ["then" form]]
  316.    ["across" form]
  317.    ["being" 
  318.     [&or "the" "each"]
  319.     &or 
  320.     [[&or "element" "elements"] 
  321.      [&or "of" "in" "of-ref"] form
  322.      &optional "using" ["index" symbolp]];; is this right?
  323.     [[&or "hash-key" "hash-keys"
  324.       "hash-value" "hash-values"]
  325.      [&or "of" "in"]
  326.      hash-table-p &optional ["using" ([&or "hash-value" "hash-values" 
  327.                        "hash-key" "hash-keys"] sexp)]]
  328.                     
  329.     [[&or "symbol" "present-symbol" "external-symbol"
  330.       "symbols" "present-symbols" "external-symbols"]
  331.      [&or "in" "of"] package-p]
  332.      
  333.     ;; Extensions for Emacs Lisp, including Lucid Emacs.
  334.     ;; (Need a general extension mechanism.)
  335.     [[&or "frame" "frames"
  336.       "screen" "screens"
  337.       "buffer" "buffers"]]
  338.  
  339.     [[&or "window" "windows"] 
  340.      [&or "of" "in"] form]
  341.  
  342.     [[&or "overlay" "overlays"
  343.       "extent" "extents"]
  344.      [&or "of" "in"] form
  345.      &optional [[&or "from" "to"] form]]
  346.  
  347.     [[&or "interval" "intervals"] 
  348.      [&or "in" "of"] form
  349.      &optional [[&or "from" "to"] form]
  350.      ["property" form]]
  351.      
  352.     [[&or "key-code" "key-codes"
  353.       "key-seq" "key-seqs"
  354.       "key-binding" "key-bindings"] 
  355.      [&or "in" "of"] form
  356.      &optional ["using" ([&or "key-code" "key-codes"
  357.                   "key-seq" "key-seqs"
  358.                   "key-binding" "key-bindings"] 
  359.              sexp)]]
  360.     ;; For arbitrary extensions, recognize anything else.
  361.     [symbolp &rest [&or symbolp form]]
  362.     ]
  363.    
  364.    ;; arithmetic - must be last since all parts are optional.
  365.    [[&optional [[&or "from" "downfrom" "upfrom"] form]]
  366.     [&optional [[&or "to" "downto" "upto" "below" "above"] form]]
  367.     [&optional ["by" form]]
  368.     ]))
  369.  
  370. (def-edebug-spec loop-initial-final
  371.   (&or ["initially" 
  372.     ;; [&optional &or "do" "doing"]  ;; CLtL2 doesnt allow this.
  373.     &rest loop-non-atomic-expr]
  374.        ["finally" &or 
  375.     [[&optional &or "do" "doing"] &rest loop-non-atomic-expr]
  376.     ["return" form]]))
  377.  
  378. (def-edebug-spec loop-and-clause
  379.   (loop-clause &rest ["and" loop-clause]))
  380.  
  381. (def-edebug-spec loop-clause
  382.   (&or
  383.    [[&or "while" "until" "always" "never" "thereis"] form]
  384.      
  385.    [[&or "collect" "collecting"
  386.      "append" "appending"
  387.      "nconc" "nconcing"
  388.      "concat" "vconcat"] form 
  389.      [&optional ["into" loop-var]]]
  390.  
  391.    [[&or "count" "counting"
  392.      "sum" "summing"
  393.      "maximize" "maximizing"
  394.      "minimize" "minimizing"] form
  395.      [&optional ["into" loop-var]]
  396.      loop-type-spec]
  397.  
  398.    [[&or "if" "when" "unless"]
  399.     form loop-and-clause
  400.     [&optional ["else" loop-and-clause]]
  401.     [&optional "end"]]
  402.  
  403.    [[&or "do" "doing"] &rest loop-non-atomic-expr]
  404.  
  405.    ["return" form]
  406.    loop-initial-final
  407.    ))
  408.  
  409. (def-edebug-spec loop-non-atomic-expr
  410.   ([¬ atom] form))
  411.  
  412. (def-edebug-spec loop-var
  413.   ;; The symbolp must come last to recognize e.g. (a b . c)
  414.   ;; loop-var => 
  415.   ;; (loop-var . [&or nil loop-var])
  416.   ;; (symbolp . [&or nil loop-var])
  417.   ;; (symbolp . loop-var)
  418.   ;; (symbolp . (symbolp . [&or nil loop-var]))
  419.   ;; (symbolp . (symbolp . loop-var))
  420.   ;; (symbolp . (symbolp . symbolp))
  421.   (&or (loop-var . [&or nil loop-var]) [fence symbolp]))
  422.  
  423. (def-edebug-spec loop-type-spec
  424.   (&optional ["of-type" loop-d-type-spec]))
  425.  
  426. (def-edebug-spec loop-d-type-spec
  427.   (&or (loop-d-type-spec . [&or nil loop-d-type-spec]) cl-type-spec))
  428.  
  429.  
  430.